package com.example.skudemo.utils;

import cn.hutool.core.util.StrUtil;
import com.example.skudemo.core.exception.CommonException;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;

import java.text.MessageFormat;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.concurrent.TimeUnit;

@Component
@Slf4j
public class RedisUtils {
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    /**
     * 普通缓存放入
     *
     * @param key
     * @param value
     * @return
     */
    public Boolean set(String key, Object value) {
        if (StrUtil.isBlank(key)) {
            throw new CommonException("redis key不能为空");
        }
        try {
            this.redisTemplate.opsForValue().set(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * @param key
     * @param value
     * @param time  单位为妙
     * @return
     */
    public Boolean set(String key, Object value, long time) {
        try {
            if (time > 0) {
                this.redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
            } else {
                this.redisTemplate.opsForValue().set(key, value);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 相当redis中的setNx属性
     *
     * @param key
     * @param value
     * @return
     */
    public boolean setIfAbsent(String key, Object value) {
        return this.redisTemplate.opsForValue().setIfAbsent(key, value);
    }

    /**
     * 普通缓存获取
     *
     * @param key
     * @return
     */
    public Object get(String key) {
        return key == null ? null : this.redisTemplate.opsForValue().get(key);
    }

    /**
     * 自增加多少
     *
     * @param key
     * @param number
     * @return
     */
    public Long increment(String key, Long number) {
        return this.redisTemplate.opsForValue().increment(key, number);
    }

    /**
     * 自减少多少
     *
     * @param key
     * @param number
     * @return
     */
    public Long decrement(String key, Long number) {
        return this.redisTemplate.opsForValue().decrement(key, number);
    }

    /**
     * 是否存在某个key
     *
     * @param key
     * @return
     */
    public Boolean hasKey(String key) {
        return this.redisTemplate.hasKey(key);
    }

    /**
     * 删除一个key
     *
     * @param key
     * @return
     */
    public Boolean deleteKey(String key) {
        return this.redisTemplate.delete(key);
    }

    /**
     * 删除多个key
     *
     * @param keys keys
     * @return
     */
    public long deleteBatch(Collection<String> keys) {
        Long count = this.redisTemplate.delete(keys);
        return count == null ? 0 : count;
    }

    /**
     * 往Hash中存入数据
     *
     * @param key   redis key
     * @param value 值
     */
    public void putHashBatch(String key, Map<?, ?> value) {
        this.redisTemplate.opsForHash().putAll(key, value);
    }

    /**
     * 往Hash中存储数据
     *
     * @param key
     * @param value
     * @param time  过期时间单位为秒
     */
    public void putHashBatch(String key, Map<?, ?> value, long time) {
        try {
            System.out.println(key + "==============");
            System.out.println(value + "=============");
            this.redisTemplate.opsForHash().putAll(key, value);
            this.redisTemplate.opsForHash().getOperations().expire(key, time, TimeUnit.SECONDS);
        } catch (Exception e) {
            this.log.error(MessageFormat.format("redis错误:{0}", e));
            throw new CommonException("存储redis失败");
        }
    }

    /**
     * 获取Hash中的数据
     *
     * @param key     redis key
     * @param hashKey hash key
     */
    public Object getHash(String key, String hashKey) {
        return this.redisTemplate.opsForHash().get(key, hashKey);
    }

    /**
     * 获取Hash中的数据
     *
     * @param key      redis key
     * @param hashKeys hash key
     */
    public List multiGetHashBatch(String key, Collection<Object> hashKeys) {
        return this.redisTemplate.opsForHash().multiGet(key, hashKeys);
    }

    /**
     * 往Set中存入数据
     *
     * @param key    redis key
     * @param values 值
     * @return 存入的个数
     */
    public long addSet(String key, Object... values) {
        Long count = this.redisTemplate.opsForSet().add(key, values);
        return count == null ? 0 : count;
    }

    /**
     * 删除Set中的数据
     *
     * @param key    redis key
     * @param values 值
     * @return 移除的个数
     */
    public long removeSet(String key, Object... values) {
        Long count = this.redisTemplate.opsForSet().remove(key, values);
        return count == null ? 0 : count;
    }

    /**
     * 往List中存入数据
     *
     * @param key   redis key
     * @param value 值
     * @return 存入的个数
     */
    public long pushList(String key, Object value) {
        Long count = this.redisTemplate.opsForList().rightPush(key, value);
        return count == null ? 0 : count;
    }

    /**
     * 往List中存入多个数据
     *
     * @param key    redis key
     * @param values 值
     * @return 存入的个数
     */
    public long pushListBatch(String key, Collection<Object> values) {
        Long count = this.redisTemplate.opsForList().rightPushAll(key, values);
        return count == null ? 0 : count;
    }

    /**
     * 往List中存入多个数据
     *
     * @param key    redis key
     * @param values 值
     * @return 存入的个数
     */
    public long pushListBatch(String key, Object... values) {
        Long count = this.redisTemplate.opsForList().rightPushAll(key, values);
        return count == null ? 0 : count;
    }

    /**
     * 从List中获取begin到end之间的元素
     *
     * @param key   redis key
     * @param start 开始位置
     * @param end   结束位置（start=0，end=-1表示获取全部元素）
     * @return List对象
     */
    public List<Object> getListRange(String key, int start, int end) {
        return this.redisTemplate.opsForList().range(key, start, end);
    }
}
